// 数据控制器 - 主控制模块
const UserManager = require('./user-manager')
const TagManager = require('./tag-manager')
const MovieManager = require('./movie-manager')
const CommentManager = require('./comment-manager')
const { DatabaseManager } = require('./database')

class DataController {
  constructor() {
    this.db = new DatabaseManager()
    this.userManager = new UserManager()
    this.tagManager = new TagManager()
    this.movieManager = new MovieManager()
    this.commentManager = new CommentManager()
  }

  // 测试数据库连接
  async testConnection() {
    console.log('🔗 测试数据库连接...')
    const result = await this.db.testConnection()
    
    if (result.success) {
      console.log('✅ 数据库连接成功')
    } else {
      console.error('❌ 数据库连接失败:', result.error)
    }
    
    return result
  }

  // 创建基础数据（用户和标签）
  async createBasicData() {
    console.log('🚀 开始创建基础数据...\n')
    
    // 1. 创建默认用户
    const users = await this.userManager.createDefaultUsers()
    
    if (users.length === 0) {
      console.error('❌ 没有成功创建任何用户，无法继续')
      return { success: false, error: '用户创建失败' }
    }
    
    // 2. 创建标签系统
    const tagResult = await this.tagManager.createAllTags()
    
    if (tagResult.categories.length === 0) {
      console.error('❌ 没有成功创建任何标签分类')
      return { success: false, error: '标签创建失败' }
    }
    
    console.log('\n🎉 基础数据创建完成!')
    console.log(`📊 基础数据统计:`)
    console.log(`   - 用户: ${users.length} 个`)
    console.log(`   - 标签分类: ${tagResult.categories.length} 个`)
    console.log(`   - 标签: ${tagResult.tags.length} 个`)
    
    return {
      success: true,
      users,
      tags: tagResult
    }
  }

  // 生成完整数据（电影和评论）
  async generateFullData(movieCount = 10, commentCount = 50) {
    console.log('🎬 开始生成完整数据...\n')
    
    // 1. 获取现有用户
    const { data: users, error: userError } = await this.db.supabase
      .from('user_profiles')
      .select('*')
    
    if (userError || !users || users.length === 0) {
      console.error('❌ 没有找到用户，请先创建基础数据')
      return { success: false, error: '用户数据不存在' }
    }
    
    const userData = users.map(user => ({
      authId: user.user_id,
      name: user.name,
      isAi: user.is_ai
    }))
    
    // 2. 生成电影
    const movies = await this.movieManager.generateMovies(movieCount, userData)
    
    if (movies.length === 0) {
      console.error('❌ 没有成功创建任何电影，无法生成评论')
      return { success: false, error: '电影创建失败' }
    }
    
    // 3. 为电影添加系统标签
    await this.movieManager.addSystemTagsToMovies()
    
    // 4. 生成评论
    const comments = await this.commentManager.generateComments(commentCount, movies.map(m => m.id), userData)
    
    // 5. 生成回复评论（评论数量的20%）
    const replyCount = Math.floor(commentCount * 0.2)
    const replies = await this.commentManager.generateReplies(replyCount, comments.map(c => c.id), userData)
    
    // 6. 生成评论投票
    const allComments = [...comments, ...replies]
    const votes = await this.commentManager.generateCommentVotes(allComments.map(c => c.id), userData)
    
    console.log('\n🎉 完整数据生成完成!')
    console.log(`📊 最终统计:`)
    console.log(`   - 用户: ${userData.length} 个`)
    console.log(`   - 电影: ${movies.length} 部`)
    console.log(`   - 评论: ${comments.length} 条`)
    console.log(`   - 回复: ${replies.length} 条`)
    console.log(`   - 投票: ${votes.length} 个`)
    
    return {
      success: true,
      users: userData,
      movies,
      comments,
      replies,
      votes
    }
  }

  // 一键创建所有数据
  async createAllData(movieCount = 10, commentCount = 50) {
    console.log('🎯 开始一键创建所有数据...\n')
    
    // 1. 测试连接
    const connectionTest = await this.testConnection()
    if (!connectionTest.success) {
      return { success: false, error: '数据库连接失败' }
    }
    
    // 2. 创建基础数据
    const basicData = await this.createBasicData()
    if (!basicData.success) {
      return basicData
    }
    
    // 3. 生成完整数据
    const fullData = await this.generateFullData(movieCount, commentCount)
    if (!fullData.success) {
      return fullData
    }
    
    console.log('\n🎉 所有数据创建完成!')
    return {
      success: true,
      basicData,
      fullData
    }
  }

  // 清空所有数据
  async clearAllData() {
    console.log('🗑️  开始清空所有数据...\n')
    
    try {
      // 按依赖关系顺序清空
      // 1. 清空评论投票
      await this.commentManager.clearAllVotes()
      
      // 2. 清空评论
      await this.commentManager.clearAllComments()
      
      // 3. 清空电影标签关联
      const { error: movieTagsError } = await this.db.supabase
        .from('movie_tags')
        .delete()
        .neq('id', 0)
      
      if (movieTagsError) {
        console.error('❌ 清空电影标签关联失败:', movieTagsError)
      } else {
        console.log('✅ 电影标签关联已清空')
      }
      
      // 4. 清空电影
      await this.movieManager.clearAllMovies()
      
      // 5. 清空标签
      await this.tagManager.clearAllTags()
      
      // 6. 清空用户
      await this.userManager.clearAllUsers()
      
      console.log('\n🎉 所有数据清空完成!')
      return { success: true, message: '所有数据已清空' }
    } catch (error) {
      console.error('❌ 清空数据时发生错误:', error)
      return { success: false, error: error.message }
    }
  }

  // 获取系统统计信息
  async getSystemStats() {
    console.log('📊 获取系统统计信息...\n')
    
    try {
      const [userStats, tagStats, movieStats, commentStats, voteStats] = await Promise.all([
        this.userManager.getUserStats(),
        this.tagManager.getTagStats(),
        this.movieManager.getMovieStats(),
        this.commentManager.getCommentStats(),
        this.commentManager.getCommentVoteStats()
      ])
      
      console.log('📈 系统统计信息:')
      console.log('👥 用户统计:')
      if (userStats.success) {
        const stats = userStats.stats
        console.log(`   - 总用户数: ${stats.total}`)
        console.log(`   - AI用户: ${stats.aiUsers} (${stats.aiPercentage}%)`)
        console.log(`   - 人类用户: ${stats.humanUsers}`)
      }
      
      console.log('🏷️  标签统计:')
      if (tagStats.success) {
        const stats = tagStats.stats
        console.log(`   - 分类数: ${stats.categories.total} (活跃: ${stats.categories.active})`)
        console.log(`   - 标签数: ${stats.tags.total} (活跃: ${stats.tags.active})`)
        console.log(`   - 总使用次数: ${stats.tags.totalUsage}`)
      }
      
      console.log('🎬 电影统计:')
      if (movieStats.success) {
        const stats = movieStats.stats
        console.log(`   - 总电影数: ${stats.total}`)
        console.log(`   - AI电影: ${stats.aiMovies} (${stats.aiPercentage}%)`)
        console.log(`   - 人类电影: ${stats.humanMovies}`)
        console.log(`   - 平均评分: ${stats.avgRating}`)
        console.log(`   - 总浏览量: ${stats.totalViews}`)
        console.log(`   - 总点赞数: ${stats.totalLikes}`)
      }
      
      console.log('💬 评论统计:')
      if (commentStats.success) {
        const stats = commentStats.stats
        console.log(`   - 总评论数: ${stats.total}`)
        console.log(`   - 一级评论: ${stats.topLevel}`)
        console.log(`   - 回复评论: ${stats.replies} (${stats.replyPercentage}%)`)
        console.log(`   - 总点赞: ${stats.totalLikes}`)
        console.log(`   - 总点踩: ${stats.totalDislikes}`)
        console.log(`   - 点赞/点踩比: ${stats.likeDislikeRatio}`)
      }
      
      console.log('👍 投票统计:')
      if (voteStats.success) {
        const stats = voteStats.stats
        console.log(`   - 总投票数: ${stats.total}`)
        console.log(`   - 点赞: ${stats.likes} (${stats.likePercentage}%)`)
        console.log(`   - 点踩: ${stats.dislikes} (${stats.dislikePercentage}%)`)
      }
      
      return {
        success: true,
        userStats,
        tagStats,
        movieStats,
        commentStats,
        voteStats
      }
    } catch (error) {
      console.error('❌ 获取统计信息时发生错误:', error)
      return { success: false, error: error.message }
    }
  }

  // 检查数据完整性
  async checkDataIntegrity() {
    console.log('🔍 检查数据完整性...\n')
    
    try {
      const checks = []
      
      // 检查用户数据
      const { data: users, error: userError } = await this.db.supabase
        .from('user_profiles')
        .select('count')
        .limit(1)
      
      checks.push({
        name: '用户数据',
        exists: !userError && users.length > 0,
        error: userError?.message
      })
      
      // 检查标签数据
      const { data: tags, error: tagError } = await this.db.supabase
        .from('tags')
        .select('count')
        .limit(1)
      
      checks.push({
        name: '标签数据',
        exists: !tagError && tags.length > 0,
        error: tagError?.message
      })
      
      // 检查电影数据
      const { data: movies, error: movieError } = await this.db.supabase
        .from('movies')
        .select('count')
        .limit(1)
      
      checks.push({
        name: '电影数据',
        exists: !movieError && movies.length > 0,
        error: movieError?.message
      })
      
      // 检查评论数据
      const { data: comments, error: commentError } = await this.db.supabase
        .from('comments')
        .select('count')
        .limit(1)
      
      checks.push({
        name: '评论数据',
        exists: !commentError && comments.length > 0,
        error: commentError?.message
      })
      
      console.log('📋 数据完整性检查结果:')
      checks.forEach(check => {
        if (check.exists) {
          console.log(`   ✅ ${check.name}: 存在`)
        } else {
          console.log(`   ❌ ${check.name}: 不存在 ${check.error ? `(${check.error})` : ''}`)
        }
      })
      
      const allValid = checks.every(check => check.exists)
      
      return {
        success: true,
        valid: allValid,
        checks
      }
    } catch (error) {
      console.error('❌ 检查数据完整性时发生错误:', error)
      return { success: false, error: error.message }
    }
  }
}

module.exports = DataController
